package writtenTraining.day21;

import java.util.*;

/**
 * day21:(1)贪心+ 规律：前后加入法：爱丽丝的人偶
 */


public class Main {
    public static void main(String[] args) {
//         贪心 + 规律
        
        // 输入
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        
        int left = 1, right = n;
        
        int[] ret = new int[n];
        int pos = 0;
//        前后加入法
//         加入前面数据， 从而保证不相邻
        while(left <= right) {
            ret[pos++] = left;
            left++;
            if(pos >= n) {
                break;
            }
            ret[pos++] = right;
            right--;
        }
        
        // 输出
        for(int i = 0; i < n - 1; i++) {
            System.out.print(ret[i] + " ");
        }
        System.out.println(ret[n-1]);
    }
}

/**
 * day21;(2)集合 + 排序：JD7 集合
 */

 class Main1 {
    public static void main(String[] args) {
        // 集合 + 排序

        // 输入结果
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(), m = in.nextInt();

        // 加入集合去重
        Set<Integer> set = new HashSet<>();

        for(int i = 0; i < n; i++) {
            set.add(in.nextInt());
        }
        for(int i = 0; i < m; i++) {
            set.add(in.nextInt());
        }

        // 加入到数组排序
        int sz = set.size();
        int[] ret = new int[sz];
        int pos= 0;
        for(int num: set) {
            ret[pos++] = num;
        }
        Arrays.sort(ret);

        // 输出结果
        for(int i =0; i < sz - 1; i++) {
            System.out.print(ret[i] + " ");
        }
        System.out.println(ret[sz-1]);
    }
}


/**
 * day21:(3)动态规划 + 字符串模型：最长回文子序列
 */

 class Main2 {
    public static void main(String[] args) {
        // 动态规划

        // 输入
        Scanner in = new Scanner(System.in);
        char[] chs = in.next().toCharArray();
        int len = chs.length;

        // 创建 dp
        int[][] dp = new int[len][len];
        // 初始化
        // 填表
        for(int i = len - 1 ; i >= 0; i--) {
            for(int j = i ; j < len; j++) {
                if(chs[i] == chs[j]) {
                    // 三种情况
                    if(i == j) {
                        // 相同位置
                        dp[i][j] = 1;
                    } else if(i+1 == j) {
                        // 相邻位置
                        dp[i][j] = 2;
                    } else if(i + 1 < j){
                        // 间隔位置
                        dp[i][j] = dp[i+1][j-1] + 2;
                    }
                } else {
                    // 不想等
                    dp[i][j] = i + 1 < j
                            ? Math.max(dp[i+1][j],dp[i][j-1])
                            : 1;
                }
            }
        }
        // 返回值
        System.out.println(dp[0][len-1]);
    }
}